import ToolRequest from '@/base/newToolAxios';
import RequestOption from '@/base/RequestOption';
import { getActToolUrl } from '@/base/constant';

const tr = new ToolRequest();

export default class CourseDao {
  /**
   * 查询跟教师用户相关的所有课程
   *
   * @param userId 用户id
   * @param courseName 课程名称（可选，用于过滤）
   * @param currentPage   当前页数
   * @param pageSize      每页大小
   * @return 课程信息与关联的项目和教师用户
   */
  async findCoursesByUserId(
    userId: number,
    courseName: string,
    currentPage: number,
    pageSize: number
  ) {
    const ro = new RequestOption();
    console.log('获取课程列表，参数:', { userId, courseName, currentPage, pageSize });
    return await tr.get(
      getActToolUrl(),
      {
        action: 'findCoursesByUserId',
        userId: userId,
        courseName: courseName,
        currentPage: currentPage,
        pageSize: pageSize
      },
      ro
    );
  }
  /**
   * 根据课程ID、课程名称查询课程。
   * 如果提供了课程ID，则根据课程ID查找用户并返回单个课程的列表（或空列表如果未找到）。
   * 如果未提供课程ID但提供了课程名称，则根据课程名称查找课程并返回匹配的课程列表（或空列表如果未找到）。
   * 注意：2个参数只能选择一个进行匹配，优先ID。
   *
   * @param {number} courseId   课程ID。
   * @param {string} courseName 课程名。
   * @return 查找到的课程列表，如果未找到则返回空列表。
   */
  async findCourse(courseId: number, courseName: string) {
    const ro = new RequestOption();
    return await tr.get(
      getActToolUrl(),
      {
        action: 'findCourse',
        courseId: courseId,
        courseName: courseName
      },
      ro
    );
  }
  
  /**
   * 获取课程列表（用于下拉框等场景）
   */
  async getCourseList() {
    const ro = new RequestOption();
    return await tr.get(
      getActToolUrl(),
      {
        action: 'getCourseList' 
      },
      ro
    );
  }

  /**
   * 创建新课程
   * 
   * @param {Object} courseData 课程数据对象，包含课程名称、学院、课程类型等信息
   * @return 创建结果
   */
  async createCourse(params: any) {
    console.log('调用创建课程API，参数:', params);
    const ro = new RequestOption();
    return await tr.post(
      getActToolUrl(),
      {
        action: 'createCourse',
        courseData: params.courseData,
        userId: params.userId
      },
      ro
    );
  }
  
  /**
   * 更新课程信息
   * 
   * @param {Object} params 包含courseData和courseId的对象
   * @return 更新结果
   */
  async updateCourse(params: any) {
    console.log('调用更新课程API，参数:', params);
    const ro = new RequestOption();
    return await tr.post(
      getActToolUrl(),
      {
        action: 'updateCourse',
        courseData: params.courseData,
        courseId: params.courseId
      },
      ro
    );
  }

  /**
   * 删除课程
   * 
   * @param {number} courseId 课程ID
   * @return 删除结果
   */
  async deleteCourse(courseId: number) {
    console.log('调用删除课程API，参数:', courseId);
    const ro = new RequestOption();
    return await tr.post(
      getActToolUrl(),
      {
        action: 'deleteCourse',
        courseId: courseId
      },
      ro
    );
  }

  /**
   * 更新课程状态
   * 
   * @param {number} courseId 课程ID
   * @param {number} status 状态值（0-未开课，1-进行中，2-已结课）
   * @return 更新结果
   */
  async updateCourseStatus(courseId: number, status: number) {
    console.log('调用更新课程状态API，参数:', { courseId, status });
    const ro = new RequestOption();
    return await tr.post(
      getActToolUrl(),
      {
        action: 'updateCourseStatus',
        courseId: courseId,
        courseStatus: status
      },
      ro
    );
  }

  /**
   * 添加项目到课程
   * 
   * @param {number} courseId 课程ID
   * @param {Array<number>} projectIds 要添加的项目ID列表
   * @return 添加结果
   */
  async addProjectsToCourse(courseId: number, projectIds: number[]) {
    console.log('调用添加项目到课程API，参数:', { courseId, projectIds });
    const ro = new RequestOption();
    return await tr.post(
      getActToolUrl(),
      {
        action: 'addProjectsToCourse',
        courseId: courseId,
        projectIds: JSON.stringify(projectIds)
      },
      ro
    );
  }

  /**
   * 获取课程成绩数据
   * 
   * @param {number} courseId 课程ID
   * @param {number} classId 班级ID（可选）
   * @param {number} teamId 小组ID（可选）
   * @param {string} studentName 学生姓名或学号（可选）
   * @param {string} studentMajor 学生专业（可选）
   * @return 课程成绩数据
   */
  async getCourseGrades(params: any) {
    console.log('调用获取课程成绩API，参数:', params);
    const ro = new RequestOption();
    return await tr.get(
      getActToolUrl(),
      {
        action: 'getCourseGrades',
        courseId: params.courseId,
        classId: params.classId,
        teamId: params.teamId,
        studentName: params.studentName,
        studentMajor: params.studentMajor,
        currentPage: params.currentPage,
        pageSize: params.pageSize
      },
      ro
    );
  }

  /**
   * 导出课程成绩数据
   * 
   * @param {number} courseId 课程ID
   * @return 导出结果
   */
  async exportCourseGrades(courseId: number) {
    console.log('调用导出课程成绩API，参数:', { courseId });
    const ro = new RequestOption();
    return await tr.get(
      getActToolUrl(),
      {
        action: 'exportCourseGrades',
        courseId: courseId
      },
      ro
    );
  }

  /**
   * 获取课程关联的班级和小组信息
   * 
   * @param {number} courseId 课程ID
   * @return 班级和小组信息
   */
  async findProjectClassesAndTeamsByCourseId(courseId: number) {
    console.log('调用获取课程班级和小组API，参数:', { courseId });
    const ro = new RequestOption();
    return await tr.get(
      getActToolUrl(),
      {
        action: 'findProjectClassesAndTeamsByCourseId',
        courseId: courseId
      },
      ro
    );
  }
  
  /**
   * 关联用户到所有课程
   * 
   * @param {number} userId 用户ID
   * @return 关联结果
   */
  async linkUserToAllCourses(userId: number) {
    console.log('调用关联用户到所有课程API，参数:', { userId });
    const ro = new RequestOption();
    return await tr.get(
      getActToolUrl(),
      {
        action: 'linkUserToAllCourses',
        userId: userId
      },
      ro
    );
  }

  /**
   * 查询课程关联的项目
   *
   * @param {number} courseId 课程ID
   * @param {string} projectName 项目名称（可选，用于过滤）
   * @param {number} projectStatus 项目状态（可选，用于过滤）
   * @param {number} currentPage 当前页数
   * @param {number} pageSize 每页大小
   * @return 课程关联的项目列表
   */
  async findCourseProjects(
    courseId: number,
    projectName: string | undefined,
    projectStatus: number | undefined,
    currentPage: number,
    pageSize: number
  ) {
    console.log('获取课程项目列表，参数:', { courseId, projectName, projectStatus, currentPage, pageSize });
    const ro = new RequestOption();
    return await tr.get(
      getActToolUrl(),
      {
        action: 'findCourseProjects',
        courseId: courseId,
        projectName: projectName,
        projectStatus: projectStatus,
        currentPage: currentPage,
        pageSize: pageSize
      },
      ro
    );
  }

  /**
   * 从课程中移除项目
   *
   * @param {number} courseId 课程ID
   * @param {number} projectId 项目ID
   * @return 移除结果
   */
  async removeCourseProject(courseId: number, projectId: number) {
    console.log('移除课程项目，参数:', { courseId, projectId });
    const ro = new RequestOption();
    return await tr.post(
      getActToolUrl(),
      {
        action: 'removeCourseProject',
        courseId: courseId,
        projectId: projectId
      },
      ro
    );
  }
}
